home *** CD-ROM | disk | FTP | other *** search
/ Amiga Tools 5 / Amiga Tools 5.iso / tools / developer-tools / c-tools / vbcc / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-06-10  |  20.8 KB  |  600 lines
  1. /*  $VER: vbcc (main.c) V0.3    */
  2.  
  3. #include "vbc.h"
  4.  
  5. int endok=1;
  6. int line,errors;
  7.  
  8. char errfname[100]; /*  VORSICHT: Diese Konstante kommt nochmal vor */
  9.  
  10. char *multname[]={"","s"};
  11. void raus(void)
  12. /*  Beendet das Programm                                            */
  13. {
  14.     if(DEBUG) printf("raus()\n");
  15.     if(!endok) printf("unexpected end of file\n");
  16.     if(errors) printf("%d error%s found!\n",errors,multname[errors>1]);
  17.     while(nesting>=0) leave_block();
  18.     if(in[0]&&(c_flags[17]&USEDFLAG)) fclose(in[0]);
  19.     if(ppout) fclose(ppout);
  20.     if(out) fclose(out);
  21.     if(ic1) fclose(ic1);
  22.     if(ic2) fclose(ic2);
  23.     if(!(c_flags[17]&USEDFLAG)) pp_free();
  24.     if(endok&&!errors) exit(EXIT_SUCCESS); else exit(EXIT_FAILURE);
  25. }
  26.  
  27. int eof;
  28.  
  29. void translation_unit(void)
  30. /*  bearbeitet translation_unit                                     */
  31. /*  hier z.Z. nur provisorisch                                      */
  32. {
  33.     while(1){
  34.         killsp();
  35.         if(c_flags[18]&USEDFLAG){
  36.             if(*s==EOF) raus();
  37.             fputs(string,ppout);fputc('\n',ppout);
  38.             s=string;*s=0;
  39.         }else{
  40.             if(eof||(!isalpha((unsigned char)*s)&&*s!='_')){
  41.                 if(!eof) error(0);
  42.                 raus();
  43.             }
  44.             endok=0;
  45.             var_declaration();
  46.             endok=1;
  47.         }
  48.     }
  49. }
  50.  
  51. void dontwarn(char *p)
  52. /*  schaltet flags fuer Meldung auf DONTWARN    */
  53. {
  54.     int i;
  55.     if(*p!='=') error(4,"-dontwarn");
  56.     i=atoi(p+1);
  57.     if(i>=err_num) error(159,i);
  58.     if(i<0){
  59.         for(i=0;i<err_num;i++)
  60.             if(!(err_out[i].flags&(ANSIV|FATAL)))
  61.                 err_out[i].flags|=DONTWARN;
  62.         return;
  63.     }
  64.     if(err_out[i].flags&(ANSIV|FATAL)) error(160,i);
  65.     err_out[i].flags|=DONTWARN;
  66. }
  67. void warn(char *p)
  68. /*  schaltet Warnung fuer Meldung ein           */
  69. /*  wenn Nummer<0 sind alle Warnungen ein       */
  70. {
  71.     int i;
  72.     if(*p!='=') error(4,"-warn");
  73.     i=atoi(p+1);
  74.     if(i>=err_num) error(159,i);
  75.     if(i<0){
  76.         for(i=0;i<err_num;i++) err_out[i].flags&=~DONTWARN;
  77.         return;
  78.     }else err_out[i].flags&=~DONTWARN;
  79. }
  80.  
  81. extern char *copyright;
  82.  
  83. int main(int argc,char *argv[])
  84. {
  85.     int i,j,fname=0;
  86.     c_flags_val[9].f=dontwarn;
  87.     c_flags_val[10].f=warn;
  88.     for(i=1;i<argc;i++){
  89.         if(*argv[i]!='-'){  /*  kein Flag   */
  90.             if(fname){
  91.                 error(1);
  92.             }else fname=i;
  93.         }else{
  94.             int flag=0;
  95.             for(j=0;j<MAXCF;j++){
  96.                 size_t l;
  97.                 if(!c_flags_name[j]) continue;
  98.                 l=strlen(c_flags_name[j]);
  99.                 if(l>0&&!strncmp(argv[i]+1,c_flags_name[j],l)){
  100.                     flag=1;
  101.                     if((c_flags[j]&(USEDFLAG|FUNCFLAG))==USEDFLAG){error(2,argv[i]);break;}
  102.                     c_flags[j]|=USEDFLAG;
  103.                     if(c_flags[j]&STRINGFLAG){
  104.                         if(argv[i][l+1]!='='){error(3,argv[i]);}
  105.                         c_flags_val[j].p=&argv[i][l+2];
  106.                     }
  107.                     if(c_flags[j]&VALFLAG){
  108.                         if(argv[i][l+1]!='='){error(4,argv[i]);}
  109.                         c_flags_val[j].l=atol(&argv[i][l+2]);
  110.                     }
  111.                     if(c_flags[j]&FUNCFLAG) c_flags_val[j].f(&argv[i][l+1]);
  112.                 }
  113.             }
  114.             for(j=0;j<MAXGF;j++){
  115.                 size_t l;
  116.                 if(!g_flags_name[j]) continue;
  117.                 l=strlen(g_flags_name[j]);
  118.                 if(l>0&&!strncmp(argv[i]+1,g_flags_name[j],l)){
  119.                     flag=1;
  120.                     if((g_flags[j]&(USEDFLAG|FUNCFLAG))==USEDFLAG){error(2,argv[i]);break;}
  121.                     g_flags[j]|=USEDFLAG;
  122.                     if(g_flags[j]&STRINGFLAG){
  123.                         if(argv[i][l+1]!='='){error(3,argv[i]);}
  124.                         g_flags_val[j].p=&argv[i][l+2];
  125.                     }
  126.                     if(g_flags[j]&VALFLAG){
  127.                         if(argv[i][l+1]!='='){error(4,argv[i]);}
  128.                         g_flags_val[j].l=atol(&argv[i][l+2]);
  129.                     }
  130.                     if(g_flags[j]&FUNCFLAG) g_flags_val[j].f(&argv[i][l+1]);
  131.                 }
  132.             }
  133.             if(!flag){error(5,argv[i]);}
  134.         }
  135.     }
  136.     if(!(c_flags[6]&USEDFLAG)) printf(copyright);
  137.     if(!(c_flags[17]&USEDFLAG)) pp_init();
  138.     if(!(c_flags[8]&USEDFLAG)) c_flags_val[8].l=10; /* max. Fehlerzahl */
  139.     if(!fname){error(6);}
  140.     inname=argv[fname];
  141.     strcpy(errfname,inname);    /*  das hier ist Muell - wird noch geaendert    */
  142.     if(!init_cg()) exit(EXIT_FAILURE);
  143.     if(c_flags[17]&USEDFLAG){
  144.         in[0]=fopen(inname,"r");
  145.         if(!in[0]) {error(7,inname);}
  146.     }else{
  147.         if(!pp_include(inname)) error(7,inname);
  148.     }
  149.     if(!(c_flags[18]&USEDFLAG)&&!(c_flags[5]&USEDFLAG)){
  150.         out=open_out(inname,"asm");
  151.         if(!out){
  152.             if(c_flags[17]&USEDFLAG){
  153.                 fclose(in[0]);
  154.             }else{
  155.                 pp_free();
  156.             }
  157.             exit(EXIT_FAILURE);
  158.         }
  159.     }
  160.     if(c_flags[2]&USEDFLAG) ic1=open_out(inname,"ic1");
  161.     if(c_flags[3]&USEDFLAG) ic2=open_out(inname,"ic2");
  162.     if(c_flags[18]&USEDFLAG) ppout=open_out(inname,"i");
  163.     if(c_flags[4]&USEDFLAG) DEBUG=c_flags_val[4].l; else DEBUG=0;
  164.     switch_count=0;break_label=0;
  165.     *string=0;s=string;line=0;
  166.     killsp();
  167.     nesting=-1;enter_block();
  168.     translation_unit();
  169. }
  170.  
  171. void prd(FILE *o,struct Typ *p)
  172. /* Gibt einen Typ auf dem Bildschirm aus    */
  173. {
  174.     int f;
  175.     if(!p) {fprintf(o,"empty type ");return;}
  176.     f=p->flags;
  177. /*    fprintf(o,"(Sizeof=%d,flags=%d)",szof(p),f);*/
  178.     if(type_uncomplete(p)) {fprintf(o,"incomplete ");}
  179.     if(f&CONST) {fprintf(o,"const ");f&=~CONST;}
  180.     if(f&STRINGCONST) {fprintf(o,"string-const ");f&=~STRINGCONST;}
  181.     if(f&VOLATILE) {fprintf(o,"volatile ");f&=~VOLATILE;}
  182.     if(f&UNSIGNED) {fprintf(o,"unsigned ");f&=~UNSIGNED;}
  183.     if(f==FUNKT) {fprintf(o,"function with parameters (");
  184.                   prl(o,p->exact);
  185.                   fprintf(o,") returning ");prd(o,p->next);return;}
  186.     if(f==STRUCT){fprintf(o,"struct with components {");
  187.                   prl(o,p->exact);fprintf(o,"} ");
  188.                   return;
  189.     }
  190.     if(f==UNION) {fprintf(o,"union with components {");
  191.                   prl(o,p->exact);fprintf(o,"} ");
  192.                   return;
  193.     }
  194.     if(f==POINTER) {fprintf(o,"pointer to ");prd(o,p->next);return;}
  195.     if(f==ARRAY) {fprintf(o,"array [size %d] of ",p->size);prd(o,p->next);return;}
  196.     fprintf(o,"%s",typname[f]);
  197. }
  198. void prl(FILE *o,struct struct_declaration *p)
  199. /* Gibt eine struct_declaration auf dem Bildschirm aus */
  200. {
  201.     int i;
  202.     for(i=0;i<p->count;i++) {fprintf(o," %d.:",i); prd(o,(*p->sl)[i].styp);}
  203. }
  204. void freetyp(struct Typ *p)
  205. /* Gibt eine Typ-Liste frei, aber keine struct_declaration oder so */
  206. {
  207.     int f;struct Typ *merk;
  208.     if(DEBUG&8){printf("freetyp: ");prd(stdout,p);printf("\n");}
  209.     while(p){
  210.         merk=p->next;
  211.         f=p->flags&15;
  212.         if(merk&&f!=ARRAY&&f!=POINTER&&f!=FUNKT){ierror(0);return;}
  213.         free(p);
  214.         p=merk;
  215.     }
  216. }
  217. void cpbez(char *m)
  218. /* kopiert den naechsten Bezeichner von s nach m */
  219. {
  220.     char *last=m+MAXI-1;int warned=0;
  221.     if(DEBUG&128) printf("Before cpbez:%s\n",s);
  222.     while(isalpha((unsigned char)*s)||isdigit((unsigned char)*s)||*s=='_'){
  223.         if(m<last){
  224.             *m++=*s++;
  225.         }else{
  226.             s++;
  227.             if(!warned){
  228.                 error(206,MAXI-1);
  229.                 warned=1;
  230.             }
  231.         }
  232.     }
  233.     *m=0;
  234.     if(DEBUG&128) printf("After cpbez:%s\n",s);
  235. }
  236. void cpnum(char *m)
  237. /* kopiert die naechste int-Zahl von s nach m   */
  238. /* muss noch erheblich erweiter werden          */
  239. {
  240.     if(DEBUG&128) printf("Before cpnum:%s\n",s);
  241.     while(isdigit((unsigned char)*s)) *m++=*s++;
  242.     *m++=0;
  243.     if(DEBUG&128) printf("After cpnum:%s\n",s);
  244.  
  245. }
  246. void killsp(void)
  247. /*  Ueberspringt Fuellzeichen                   */
  248. /*  noch einige unschoene Dinge drin            */
  249. {
  250.     int r;
  251.     if(DEBUG&128) printf("Before killsp:%s\n",s);
  252.     if(eof) raus();
  253.     while(isspace((unsigned char)*s)){
  254. /*        if(*s=='\n') {line++;if(DEBUG&1) printf("Line %d\n",line);}*/
  255.         s++;
  256.     }
  257.     if(*s==0){
  258.         do{
  259.             if(c_flags[17]&USEDFLAG) r=(fgets(string,MAXINPUT,in[0])!=0);
  260.                 else                 r=pp_nextline();
  261.             if(!r){
  262.                 /*raus();*/
  263.                 if(DEBUG&1) printf("nextline/fgets returned 0\n");
  264.                 s=string;*s=0;
  265.                 eof=1;
  266.                 return;
  267.             }else{
  268.                 line++;
  269.                 read_new_line=1;
  270.                 if(DEBUG&1) printf("Line %d\n",line);}
  271.                 if(!strncmp("#pragma",string,7)) error(163);
  272.                 if(!strncmp("#pragma only-inline on",string,22)){
  273.                     if(DEBUG&1) printf("only-inline on\n");
  274.                     only_inline=1;
  275.                 }
  276.                 if(!strncmp("#pragma only-inline off",string,23)){
  277.                     if(DEBUG&1) printf("only-inline off\n");
  278.                     only_inline=2;
  279.                 }
  280.                 if(!strncmp("#pragma type ",string,13)){
  281.                 /*  Typ eines Ausdrucks im Klartext ausgeben    */
  282.                     np tree;
  283.                     s=string+13;
  284.                     tree=expression();
  285.                     if(tree&&type_expression(tree)){
  286.                         printf("type of %s is:\n",string+13);
  287.                         prd(stdout,tree->ntyp);printf("\n");
  288.                     }
  289.                     if(tree) free_expression(tree);
  290.  
  291.                 }
  292.                 if(!strncmp("#pragma tree ",string,13)){
  293.                 /*  gibt eine expression aus    */
  294.                     np tree;
  295.                     s=string+13;
  296.                     tree=expression();
  297.                     if(tree&&type_expression(tree)){
  298.                         printf("tree of %s is:\n",string+13);
  299.                         pre(stdout,tree);printf("\n");
  300.                     }
  301.                     if(tree) free_expression(tree);
  302.                 }
  303.                 if(string[0]=='#'&&isspace((unsigned char)string[1])&&isdigit((unsigned char)string[2])){
  304.                     sscanf(string+2,"%d \" %[^\"]",&line,errfname);
  305.                     if(DEBUG&1) printf("new line: %d (file=%s)\n",line,errfname);
  306.                     line--;
  307.                 }
  308.                 if(!strncmp("#line ",string,6)){
  309.                     sscanf(string+6,"%d \" %[^\"]",&line,errfname);
  310.                     if(DEBUG&1) printf("new line: %d (file=%s)\n",line,errfname);
  311.                     line--;
  312.                 }
  313.             s=string;
  314.         }while(*s=='#');
  315.         killsp();
  316.     }
  317.     if(DEBUG&128) printf("After killsp:%s\n",s);
  318. }
  319. int szof(struct Typ *t)
  320. /*  liefert die benoetigte Groesse eines Typs in Bytes      */
  321. /*  maschinenabhaengig                                      */
  322. {
  323.     int i=t->flags,j,size,m,f;
  324. /*    if(type_uncomplete(t)){
  325.         error(176);
  326.         return(0);
  327.     }*/
  328.     if((i&15)==POINTER) return(4);
  329.     if((i&15)==ARRAY) return((t->size)*szof(t->next));
  330.     if((i&15)==UNION){
  331.         for(j=0,size=0;j<t->exact->count;j++){
  332.             m=szof((*t->exact->sl)[j].styp);
  333.             if(m==0) return(0);
  334.             if(m>size) size=m;
  335.         }
  336.         return(((size+align[UNION]-1)/align[UNION])*align[UNION]); /* align */
  337.     }
  338.     if((i&15)==STRUCT){
  339.         for(j=0,size=0;j<t->exact->count;j++){
  340.             m=szof((*t->exact->sl)[j].styp);
  341.             if(m==0) return(0);
  342.             f=((*t->exact->sl)[j].styp->flags)&15;
  343.             size=((size+align[f]-1)/align[f])*align[f];
  344.             size+=m;
  345.         }
  346.         return(((size+align[STRUCT]-1)/align[STRUCT])*align[STRUCT]);
  347.     }
  348.     if(DEBUG&2) printf("sizeof(%d)=%d\n",i&15,sizetab[i&15]);
  349.     return(sizetab[i&15]);
  350. }
  351. void enter_block(void)
  352. /*  Setzt Zeiger/Struckturen bei Eintritt in neuen Block    */
  353. {
  354.     if(nesting>=MAXN){error(9,nesting);return;}
  355.     nesting++;
  356.     if(DEBUG&1) printf("enter block %d\n",nesting);
  357.     first_ilist[nesting]=last_ilist[nesting]=0;
  358.     first_sd[nesting]=last_sd[nesting]=0;
  359.     first_si[nesting]=last_si[nesting]=0;
  360.     first_var[nesting]=last_var[nesting]=0;
  361.     if(nesting==1){
  362.         first_llist=last_llist=0;
  363.         first_clist=last_clist=0;
  364.         merk_varf=merk_varl=0;
  365.         merk_ilistf=merk_ilistl=0;
  366.         merk_sif=merk_sil=0;
  367. /*  struct-declarations erst ganz am Schluss loeschen. Um zu vermeiden,     */
  368. /*  dass struct-declarations in Prototypen frei werden und dann eine        */
  369. /*  spaetere struct, dieselbe Adresse bekommt und dadurch gleich wird.      */
  370. /*  Nicht sehr schoen - wenn moeglich noch mal aendern.                     */
  371. /*        merk_sdf=merk_sdl=0;*/
  372.         afterlabel=0;
  373.     }
  374. }
  375. void leave_block(void)
  376. /*  Setzt Zeiger/Struckturen bei Verlassen eines Blocks     */
  377. {
  378.     int i;
  379.     for(i=1;i<=MAXR;i++)
  380.         if(regbnesting[i]==nesting) regsbuf[i]=0;
  381.  
  382.     if(nesting<0){error(10);return;}
  383.     if(DEBUG&1) printf("leave block %d\n",nesting);
  384.     if(nesting>0){
  385.         if(merk_varl) merk_varl->next=first_var[nesting]; else merk_varf=first_var[nesting];
  386.         if(last_var[nesting]) merk_varl=last_var[nesting];
  387.         if(merk_sil) merk_sil->next=first_si[nesting]; else merk_sif=first_si[nesting];
  388.         if(last_si[nesting]) merk_sil=last_si[nesting];
  389.         if(merk_sdl) merk_sdl->next=first_sd[nesting]; else merk_sdf=first_sd[nesting];
  390.         if(last_sd[nesting]) merk_sdl=last_sd[nesting];
  391.         if(merk_ilistl) merk_ilistl->next=first_ilist[nesting]; else merk_ilistf=first_ilist[nesting];
  392.         if(last_ilist[nesting]) merk_ilistl=last_ilist[nesting];
  393.     }
  394.     if(nesting==1){
  395.         if(merk_varf) gen_vars(merk_varf);
  396.         if(first_llist) free_llist(first_llist);
  397.         if(first_clist) free_clist(first_clist);
  398.         if(merk_varf) free_var(merk_varf);
  399.         if(merk_sif) free_si(merk_sif);
  400. /*  struct-declarations erst ganz am Schluss loeschen. Um zu vermeiden,     */
  401. /*  dass struct-declarations in Prototypen frei werden und dann eine        */
  402. /*  spaetere struct, dieselbe Adresse bekommt und dadurch gleich wird.      */
  403. /*  Nicht sehr schoen - wenn moeglich noch mal aendern.                     */
  404. /*        if(merk_sdf) free_sd(merk_sdf);*/
  405.         if(merk_ilistf) free_ilist(merk_ilistf);
  406.     }
  407.     if(nesting==0){
  408. /*  struct-declarations erst ganz am Schluss loeschen. Um zu vermeiden,     */
  409. /*  dass struct-declarations in Prototypen frei werden und dann eine        */
  410. /*  spaetere struct, dieselbe Adresse bekommt und dadurch gleich wird.      */
  411. /*  Nicht sehr schoen - wenn moeglich noch mal aendern.                     */
  412.         if(merk_sdf) free_sd(merk_sdf);
  413.         if(first_var[0]) gen_vars(first_var[0]);
  414.         if(first_var[0]) free_var(first_var[0]);
  415.         if(first_sd[0]) free_sd(first_sd[0]);
  416.         if(first_si[0]) free_si(first_si[0]);
  417.         if(first_ilist[0]) free_ilist(first_ilist[0]);
  418.     }
  419.     nesting--;
  420. }
  421. void pra(FILE *f,struct argument_list *p)
  422. /*  Gibt argument_list umgekehrt auf Bildschirm aus             */
  423. {
  424.     if(p->next){ pra(f,p->next);fprintf(f,",");}
  425.     if(p->arg) pre(f,p->arg);
  426. }
  427. void pre(FILE *f,np p)
  428. /*  Gibt expression auf Bildschirm aus                          */
  429. {
  430.     int c;
  431.     c=p->flags;
  432.     if(p->sidefx) fprintf(f,"/");
  433.     if(p->lvalue) fprintf(f,"|");
  434.     if(c==CALL){fprintf(f,"call-function(");pre(f,p->left);fprintf(f,")(");
  435.                 if(p->alist) pra(f,p->alist);
  436.                 fprintf(f,")");return;}
  437.     if(c==CAST){fprintf(f,"cast(");pre(f,p->left);
  438.                 fprintf(f,"->");prd(f,p->ntyp);
  439.                 fprintf(f,")");return;}
  440.     if(c==MEMBER){if(p->identifier) fprintf(f,".%s",p->identifier);return;}
  441.     if(c==IDENTIFIER){if(p->identifier) fprintf(f,"%s",p->identifier);
  442.         fprintf(f,"+");printval(f,&p->val,LONG,1); return;}
  443.     fprintf(f,"%s(",ename[c]);
  444.     if(p->left) pre(f,p->left);
  445.     if(p->right){
  446.         fprintf(f,",");
  447.         pre(f,p->right);
  448.     }
  449.     fprintf(f,")");
  450.     if(c==CEXPR||c==PCEXPR){fprintf(f,"(value="); printval(f,&p->val,p->ntyp->flags,1); fprintf(f,")");}
  451. }
  452. void printval(FILE *f,union atyps *p,int t,int verbose)
  453. /*  Gibt atyps aus                                      */
  454. {
  455.     if(t==CHAR){if(verbose)fprintf(f,"C");vlong=zc2zl(p->vchar);printzl(f,vlong);}
  456.     if(t==(UNSIGNED|CHAR)){if(verbose)fprintf(f,"UC");vulong=zuc2zul(p->vuchar);printzul(f,vulong);}
  457.     if(t==SHORT){if(verbose)fprintf(f,"S");vlong=zs2zl(p->vshort);printzl(f,vlong);}
  458.     if(t==(UNSIGNED|SHORT)){if(verbose) fprintf(f,"US");vulong=zus2zul(p->vushort);printzul(f,vulong);}
  459.     if(t==FLOAT){if(verbose)fprintf(f,"F");vdouble=zf2zd(p->vfloat);printzd(f,vdouble);}
  460.     if(t==DOUBLE){if(verbose)fprintf(f,"D");printzd(f,p->vdouble);}
  461.     if(t==INT){if(verbose)fprintf(f,"I");vlong=zi2zl(p->vint);printzl(f,vlong);}
  462.     if(t==LONG){if(verbose)fprintf(f,"L");printzl(f,p->vlong);}
  463.     if(t==(UNSIGNED|INT)){if(verbose)fprintf(f,"UI");vulong=zui2zul(p->vuint);printzul(f,vulong);}
  464.     if(t==(UNSIGNED|LONG)){if(verbose)fprintf(f,"UL");printzul(f,p->vulong);}
  465.     /*  das hier ist nicht wirklich portabel    */
  466.     if(t==POINTER){if(verbose)fprintf(f,"P");vulong=zp2zul(p->vpointer);printzul(f,vulong);}
  467. }
  468. void pric2(FILE *f,struct IC *p)
  469. /*  Gibt ein IC aus */
  470. {
  471.     if(p->next&&p->next->prev!=p) {ierror(0);exit(EXIT_FAILURE);}
  472.     if(p->code>=LABEL&&p->code<=BRA){
  473.         if(p->code==LABEL) fprintf(f,"L%d",p->typf);
  474.         else fprintf(f,"\t\t%s L%d",ename[p->code],p->typf);
  475.     }else{
  476.         fprintf(f,"\t\t%s ",ename[p->code]);
  477.         if(p->typf&UNSIGNED) fprintf(f,"unsigned ");
  478.         if(p->typf) fprintf(f,"%s ",typname[p->typf&15]);
  479.         probj(f,&p->q1,p->typf,1);
  480.         if(p->q2.flags){fprintf(f,",");probj(f,&p->q2,p->typf,1);}
  481.         if(p->z.flags){fprintf(f,"->");probj(f,&p->z,p->typf,1);}
  482.         if(p->code==ASSIGN||p->code==PUSH||p->code==POP) fprintf(f," size=%d",p->q2.reg);
  483.         if((p->code==SAVEREGS||p->code==RESTOREREGS)&&p->q1.reg) fprintf(f," except %s",regnames[p->q1.reg]);
  484.     }
  485.     fprintf(f,"\n");
  486. }
  487. void pric(FILE *f,struct IC *p)
  488. /*  Gibt IC-Liste auf dem Bildschirm aus                */
  489. {
  490.     while(p){
  491.         pric2(f,p);
  492. /*        if(p->q1.am||p->q2.am||p->z.am) ierror(0);*/
  493.         p=p->next;
  494.     }
  495. }
  496.  
  497. char *errstr[]={"","warning","error"};
  498.  
  499. void error(int errn,...)
  500. /*  Behandelt Ausgaben wie Fehler und Meldungen */
  501. {
  502.     int type=0;
  503.     va_list vl;
  504.     if(err_out[errn].flags&DONTWARN) return;
  505.     va_start(vl,errn);
  506.     if(err_out[errn].flags&WARNING) type=1;
  507.     if(err_out[errn].flags&ERROR) type=2;
  508.     if(c_flags[7]&USEDFLAG){
  509.         if(err_out[errn].flags&ANSIV) type=2; else type=0;
  510.     }
  511.     if(type){
  512.         {if(eof) printf(">EOF\n"); else printf(">%s",string);}
  513.         if(!(c_flags[17]&USEDFLAG)){
  514.             printf("\n");
  515.             printf("%s %d in line %d of \"%s\": ",errstr[type],errn,linenr,filename[incnesting]);
  516.         }else{
  517.             printf("%s %d in line %d of \"%s\": ",errstr[type],errn,line,errfname);
  518.         }
  519.     }
  520.     if(type||(err_out[errn].flags&MESSAGE)){
  521.         vprintf(err_out[errn].text,vl);
  522.         printf("\n");
  523.     }
  524.     va_end(vl);
  525.     if(type==2){
  526.         errors++;
  527.         if(c_flags_val[8].l&&c_flags_val[8].l<=errors)
  528.             {printf("Maximum number of errors reached!\n");raus();}
  529.     }
  530.     if(err_out[errn].flags&FATAL){printf("aborting...\n");raus();}
  531. }
  532. void printzl(FILE *f,zlong x)
  533. /*  Konvertiert zlong nach ASCII                        */
  534. /*  basiert noch einigermassen auf                      */
  535. /*  Zweierkomplementdarstellung (d.h. -MIN>MAX)         */
  536. /*  Ausserdem muss max(abs(long))<=max(unsigned long)   */
  537. {
  538.     zlong zl;zulong zul;
  539.     zl=l2zl(0L);
  540.     if(zlleq(x,zl)&&!zleq(x)){
  541.         fprintf(f,"-");zl=zul2zl(t_max[LONG]);
  542.         if(zlleq(x,zlneg(zl))&&!zleqto(x,zlneg(zl))){
  543.         /*  aufpassen, da -x evtl. >LONG_MAX    */
  544.             zul=t_max[LONG];
  545.             x=zladd(x,zl);
  546.         } else zul=ul2zul(0UL);
  547.         x=zlneg(x);
  548.         vulong=zl2zul(x);
  549.         zul=zuladd(zul,vulong);
  550.     }else zul=zl2zul(x);
  551.     printzul(f,zul);
  552. }
  553. void printzul(FILE *f,zulong x)
  554. /*  Konvertiert zulong nach ASCII                       */
  555. {
  556.     zulong zul;unsigned long l;
  557.     if(DEBUG&64) printf("printzul:%lu\n",x);
  558.     zul=ul2zul(10UL);
  559.     if(!zuleq(zuldiv(x,zul))) printzul(f,zuldiv(x,zul));
  560.     zul=zulmod(x,zul);l=zul2ul(zul);
  561.     fprintf(f,"%c",(int)(l+'0'));
  562. }
  563. void printzd(FILE *f,zdouble x)
  564. /*  Konvertiert zdouble nach ASCII, noch nicht fertig   */
  565. {
  566.     fprintf(f,"sorry, floating point not yet");
  567. }
  568. FILE *open_out(char *name,char *ext)
  569. /*  Haengt ext an name an und versucht diese File als output zu oeffnen */
  570. {
  571.     char *s,*p;FILE *f;
  572.     s=mymalloc(strlen(name)+strlen(ext)+2);
  573.     strcpy(s,name);
  574.     p=s+strlen(s);
  575.     while(p>=s){
  576.         if(*p=='.'){*p=0;break;}
  577.         p--;
  578.     }
  579.     strcat(s,".");
  580.     strcat(s,ext);
  581.     f=fopen(s,"w");
  582.     if(!f) printf("Couldn't open <%s> for output!\n",s);
  583.     free(s);
  584.     return(f);
  585. }
  586. void *mymalloc(size_t size)
  587. /*  Belegt Speicher mit Abfrage     */
  588. {
  589.     void *p;static int safe;
  590.     /*  Um ein Fehlschlagen bei size==0 zu vermeiden; nicht sehr schoen,    */
  591.     /*  aber das einfachste...                                              */
  592.     if(size==0) size=1;
  593.     if(!(p=malloc(size))){
  594.         error(12);
  595.         raus();
  596.     }
  597.     return(p);
  598. }
  599.  
  600.